Rate-compatible low density parity check coding for hybrid ARQ

ABSTRACT

A new rate compatible coding approach is disclosed herein which takes advantage of the structure of irregular repeat accumulate (IRA) type codes, a special class of low density parity check codes.

BACKGROUND OF INVENTION

The invention relates generally to digital data communication systems and more particularly to coding techniques for addressing transmission errors in such systems.

There are basically two approaches to controlling transmission errors in digital data communication systems: automatic repeat request (ARQ) and forward error correction (FEC). Although ARQ schemes offer high system reliability, they also are subject to poor throughput with increasing channel error rates, such as in a wireless communication channel. FEC schemes offer the possibility of constant throughput but with less reliability than ARQ schemes. Various schemes have been proposed which combine the two approaches, typically referred to as “hybrid” ARQ techniques, in which some form of coding technique is utilized at the transmitter and receiver, and decoding errors trigger retransmission requests.

An advantageous coding technique which proves to be very useful when utilized with hybrid ARQ is what is referred to in the art as “rate compatible” coding. Rate compatible codes are a family of nested error correction codes where the codeword bits from higher rate codes are embedded in the lower-rate codes. Thus, a hybrid ARQ scheme can achieve incremental redundancy by having a transmitter send the higher-rate coded bits first and send additional parity bits later if required from the receiver. There are two basic approaches to obtaining rate compatible codes—one is by “puncturing” code bits in a low-rate mother code to obtain a higher rate code; the other is by “extending” a high-rate mother code to lower-rate codes by appending more parity bits. Rate compatible codes were first introduced using puncturing on convolutional codes. See J. Hagenauer, “Rate Compatible Punctured Convolutional Codes (RCPC codes) and their Applications,” IEEE Trans. Commun., Vol. 36, No. 4, pp. 389-400 (April 1988). Recently, attempts have been made to design rate compatible codes for what are known in the art as low density parity check (LDPC) codes. See, e.g., J. Li and K. Narayanan, “Rate-Compatible Low-Density Parity Check Codes for Capacity-Approaching ARQ Schemes in Packet Data Communications,” in Proc. Int. Conf. Commun., Internet, and Inform. Techn. (CIIT) (Nov. 2002). LDPC codes are attractive because they offer good performance while enjoying lower decoding complexity. A puncturing approach for irregular LDPC codes has been proposed which optimizes the degree profiles of an LDPC code ensemble based on density evolution analysis. See J. Ha and S. McLoughlin, “Optimal Puncturing of Irregular Low-Density Parity-Check Codes,” in Proc. IEEE Int. Conf. Commun. (ICC), pp. 3110-14 (May 2003). While showing good puncturing profiles that approach capacity, the results presume an infinite codeword length, which might not be suitable for design of rate compatible LDPC with short block length. Recently, a new puncturing approach has been proposed specifically for finite-length LDPC which is based on grouping nodes with different recoverable steps. See J. Ha and S. McLaughlin, “Puncturing for Finite Length Low-Density Parity-Check Codes,” in Proc. IEEE Int. Symp. Inform. Theory (ISIT), p. 151 (June 2004).

SUMMARY OF INVENTION

A new rate compatible coding approach is disclosed herein which takes advantage of the structure of irregular repeat accumulate (IRA) type codes, a special class of low density parity check codes. A wide effective code rate range is achieved by using a hybrid approach of generating high-rate codes with a novel puncturing technique and generating low-rate codes with a novel extending technique. In accordance with an aspect of the invention, higher-rate codes are generated by deliberately puncturing the parity nodes in an advantageous mother code up to the highest desired code rate. The other higher code rates are obtained by “unpuncturing” these parity nodes, preferably in a gradual controlled manner that takes into account the number of recoverable steps for the parity nodes. The parity nodes can be grouped based on recoverable steps, and parity nodes with a maximum recoverable step can be unpunctured first with priority given to those consecutive parity nodes with a maximum recoverable step. In accordance with another aspect of the invention, the lower-rate codes can be generated by extending the mother code with mixed degree-1 and degree-2 parity nodes. An arrangement which optimizes the proportion between degree-1 and degree-2 parity nodes is also disclosed.

The rate compatible codes generated by the above techniques provide good error correction performance over a wide effective range of code rates. The codes also can achieve high throughput with a hybrid ARQ scheme in a large region of signal-to-noise ratios. Moreover, the coding techniques can be implemented with a simple encoder and a low-complexity decoder. These and other advantages of the invention will be apparent to those of ordinary skill in the art by reference to the following detailed description and the accompanying drawings.

BRIEF DESCRIPTION OF DRAWINGS

FIG. 1 is a diagram of an illustrative wireless system, suitable for practice of an embodiment of the invention.

FIG. 2 illustrates an encoder structure, suitable for practice of an embodiment of the invention.

FIG. 3A and 3B illustrate different representations of a low density parity check code. FIG. 3C shows a bipartite graph for a general low density parity check code.

FIG. 4 is a bipartite graph representation of an IRA code.

FIG. 5 is a flowchart illustrating a puncturing approach, in accordance with an embodiment of an aspect of the invention.

FIG. 6 is a diagram illustrating various useful definitions.

FIG. 7 is a diagram illustrating a pattern of punctured parity nodes in an IRA code.

FIG. 8 is a diagram illustrating a deliberate puncturing pattern in an IRA code.

FIG. 9 is a diagram illustrating extension of a parity check matrix of an LDPC code.

FIG. 10 is a bipartite graph representation of the extended RC-LDPC.

FIG. 11 is a graph illustrating function ƒ(s, r, π) curves of an extended LDPC code, R=0.1. The dashed lines are for π from 0.6 to 1.0 with step 0.05.

DETAILED DESCRIPTION

FIG. 1 is a diagram of an illustrative wireless system 100, suitable for practice of an embodiment of the present invention. The system comprises a transmitter 110 and a receiver 120, each of which can include one or more transmit/receive antennas which operate across a wireless channel 150. The transmitter 110 includes an encoder 115 and the receiver 120 includes a decoder 125. The encoder 115 and the decoder 125 operate in accordance with a rate compatible code as reflected in FIG. 1 by codes tables 131 and 132. The construction and the operation of the rate compatible code is described in further detail herein.

As depicted in FIG. 1, the wireless system 100 employs a “hybrid” automatic repeat-request (ARQ) arrangement. At 101, the transmitter 110 sends data which has been encoded by the encoder 115 using a high rate R_(M) code of the rate compatible code. The receiver 120 tries to decode the data using its decoder 125. The receiver 120 communicates its decoding success or failure with the transmitter 110 through an advantageous ARQ protocol at 102, e.g., through acknowledgment messages. If the receiver 120 fails to recover the information, the transmitter 110 at 103 sends a partial redundancy of the initial coded data in the form of parity bits. The encoder 115 and the decoder 125 use a rate compatible code, and, thus, the combination of the original coded data and the additional parity bits at the decoder 120 form a message coded at a lower rate R_(M−1). If the receiver 120 again fails to recover the information, the transmitter 110 can continue to send incremental redundancies upon request until all of the redundancies are used up and the lowest rate code R_(E) is utilized. The rate compatible codes, thus, form a family of nested error correction codes where the codeword bits from higher rate codes are embedded in the lower rate codes.

The encoder 115 and the decoder 125 preferably use rate compatible codes based on irregular repeat accumulate (IRA) coding. FIG. 2 shows a schematic diagram of an illustrative IRA encoder. A block of information bits {d_(k)} 201 are encoded by an irregular repeat code at 210. The repetition degrees of {d_(k)} are denoted by {r_(k):2≦r_(k)≦D}, where D is the maximum repetition degree. The repeated bits are interleaved at 220 to obtain {u_(j)}, and then encoded by an accumulator 230, given by $\begin{matrix} {{x_{m + 1} = {x_{m} + {\sum\limits_{i = 0}^{a - 1}u_{{am} + i}}}},{m = 0},\ldots\quad,{M - 1}} & (1) \end{matrix}$ where χ_(m) represents parity nodes with initial setting χ₀=0; α is the grouping factor. The length of the parity bits is M=n/α, where n=Σ_(k=1) ^(K)r_(k). The final coded bits {b_(i)}_(i=1) ^(N) are the collection of the information bits {d_(k)}_(k=1) ^(K) 204 and the parity bits {χ_(m)}_(m=1) ^(N−K) 205.

IRA codes are a special class of what are referred to as low density parity check (LDPC) codes. An LDPC code is a linear block code specified by a very sparse parity check matrix H, such as the one depicted in FIG. 3A. The code can also be represented by a bipartite graph consisting of two types of nodes—variable nodes and check codes, as shown in FIG. 3B. Each code bit is a variable node while each parity check or each row of the parity check matrix represents a check node. An edge in the graph is placed between variable node i and check node j if H_(j,i)=1. That is, each check node is connected to code bits that satisfy the single parity check (SPC) constraint. The LDPC codes are specified by two polynomials ${{\lambda(x)} = {{\sum\limits_{i = 1}^{d_{l_{\max}}}{\lambda_{i}x^{i - 1}\quad{and}\quad{\rho(x)}}} = {\sum\limits_{i = 1}^{d_{\tau_{\max}}}{\rho_{i}x^{i - 1}}}}},$ where λ_(i) is the fraction of edges in the bipartite graph that are connected to variable nodes of degree i, and ρ_(i) is the fraction of edges that are connected to check nodes of degree i. The degree profiles {λ_(i), ρ_(i)} of LDPC codes can be optimized to have capacity approaching performance for long codes. A general bipartite graph for an LDPC code is depicted in FIG. 3C. Based on the Tanner graph representation, the LDPC codes can be decoded using iterative message-passing algorithm.

Similar to LDPC codes, one can represent the IRA codes by a Tanner graph, shown in FIG. 4. The IRA code ensemble is formed by all graphs of the form of FIG. 4. Note that n=Σ_(k=1) ^(K)r_(k) is the total number of edges connecting the information bit nodes and the check nodes. Define λ_(i) as the proportion of the edges connected to the information bit nodes with degree i, i=2, . . . , D, which satisfies Σ_(i=2) ^(D)λ_(i)=1. The rate of the codes is then given by $\begin{matrix} \begin{matrix} {R = \frac{K}{K + M}} \\ {= \frac{n{\sum\limits_{i}^{\quad}{\lambda_{i}/i}}}{{n{\sum\limits_{i}^{\quad}{\lambda_{i}/i}}} + {\sum\limits_{i}^{\quad}{\lambda_{i}{n/a}}}}} \\ {= {\frac{a{\sum\limits_{i = 2}^{D}{\lambda_{i}/i}}}{1 + {a{\sum\limits_{i = 2}^{D}{\lambda_{i}/i}}}}.}} \end{matrix} & (2) \end{matrix}$ We use a polynomial to represent the repetition profile of an IRA code ensemble, i.e., $\begin{matrix} {{\lambda(x)} = {\sum\limits_{i = 2}^{D}{\lambda_{i}{x^{i - 1}.}}}} & (3) \end{matrix}$ As shown in the Tanner graph of an IRA code in FIG. 4, the check nodes are single parity check constraints for the information nodes along α interleaved edges plus 2 parity nodes from the accumulator outputs. Thus, the check nodes in an IRA code are the same as the check nodes in an LDPC code with degree α+2. The parity nodes of an IRA code can be viewed as degree-2 variable nodes in an LDPC code. The information bit nodes of an IRA code are also viewed as LDPC variable nodes with the same degree as they are in an IRA code. Therefore, IRA codes are indeed a special class of LDPC codes with semi-determined structure. Therefore, one can use the message-passing decoding algorithm which is similar to the LDPC decoding algorithm to decode the IRA codes.

In accordance with a preferred embodiment of the invention, rate compatible LDPC codes are obtained by using puncturing and extending in a hybrid-approach. The puncturing approach is used to obtain the medium to high-rate codes while the extending approach is used to obtain the medium to low-rate codes. The specific details of the puncturing approach and the extending approach are described below. When generating an initial LDPC code, it is advantageous to use the design technique disclosed in co-pending commonly-assigned U.S. patent application Ser. No. 11/095,160, entitled “METHOD FOR CONSTRUCTING FINITE-LENGTH LOW DENSITY PARITY CHECK CODES,” filed on Mar. 31, 2005, the contents of which are incorporated by reference herein. One can obtain good finite LDPC codes with medium rate, for instance, R=0.5, and use it as the mother code with which we consider the design of RC-LDPC codes next.

PUNCTURING. Puncturing has been widely used in convolutional, BCH, and turbo codes to obtain rate compatibility. With puncturing, the encoder generates all the parity bits (whole codeword), but only partial bits are transmitted. The parity coordinates that are not transmitted can be viewed as punctured. With proper puncturing, a set of higher rate codes are obtained from a low-rate mother code. In the decoder, the punctured bits are inserted as erasures and the decoding algorithm is performed as in a non-punctured codeword, i.e., the mother code. For LDPC codes, puncturing can be viewed as the deletion of the columns in the parity check matrix.

FIG. 5 is a flowchart of processing performed in puncturing an IRA-type LDPC code to obtain rate compatibility, in accordance with an embodiment of an aspect of the invention.

At step 501, the maximum number of puncture nodes, N_(p) _(max) , is computed. Given codes rates of RC-LDPC codes R₀, . . . , R_(M), where R₀ is the rate of mother code and R_(M) is the highest rate of RC-LDPC that we want to achieve by puncturing, the maximum number of punctured node is then N _(p) _(max) =N ₀(1−R ₀ /R _(M)),   (4) where N₀ is block length of the mother code.

The puncture nodes can be grouped into different groups. If a check node has only one punctured node, the check node can be referred to as a “survived” check node (or a one-step survived check node), and the punctured node which has at least one survived check node connected is referred to as a “one step recoverable” (1SR) node. This is depicted in FIG. 6. A check node having two punctured variable nodes connected is then a dead node. The 1SR nodes can be recovered during the first iteration of an iterative message-passing decoder on binary erasure channels (BEC). On AWGN channels, the 1SR nodes may not be recovered but will have messages with a certain reliability from the SPC decoding. For the sake of simplicity, it will still be referred to as recovered for the punctured nodes on AWGN channels. If a variable node has at least one survive check node neighbor that has at least one (k−1)SR node and others are mSR nodes, where 0≦m≦k−1, this variable node is then called a “k step recoverable” node (kSR). Thus, all punctured nodes can be grouped into different groups, the group G_(k), k=1, . . . , K_(G), consisting of all the kSR punctured nodes. It is assumed that a k₁SR node has a more reliable message from a survived check node at the k₂th iteration if k₁<k₂, and a kSR node connected with more survived check nodes will be recovered with a more reliable message. The expression $\begin{matrix} {{\sum\limits_{k}^{\quad}{\mathcal{G}_{k}}} \geq N_{p_{\max}}} & (5) \end{matrix}$ represents a constraint on puncturing.

At step 502, the N_(pmax) parity nodes are “deliberately” punctured to obtain the RC-LDPC code of rate R_(M). The notion of “deliberate” puncturing is described below. The parity nodes are punctured based on the criterion of minimizing the maximal step recoverable punctured nodes.

At step 503, the punctured nodes of recoverable step k are assigned to group G_(k), k=1, . . . , K_(G). Also, assign the label−1 to two consecutive nodes with maximal recoverable step, K_(G), and label−0 to other nodes with step K_(G).

At step 504, the punctured nodes are then “unpunctured” to obtain the lower code rate gradually. We first unpuncture the punctured node with the maximum recoverable step, K_(G), and label−1 first. After using all the label−1 nodes in the group G_(K) _(G) , we then un-puncture the ones with label−0. Note that after unpuncturing each node, we update the recoverable step and labels for all rest punctured nodes.

At step 505, after all the nodes with step K_(G) un-punctured, set step K_(G=K) _(G)−1 and assign the labels to the punctured nodes currently with K_(G).

Processing continues by unpuncturing the punctured nodes at steps 504 and 505 until, at step 506, all the desired lower code rate are obtained.

The puncturing approach depicted in FIG. 5 takes advantage of important features of IRA-type codes. First, in a systematic IRA code, one knows exactly which nodes are information nodes and what are parity nodes. During the decoding, the information nodes have to have more reliable messages. Secondly, it is seen from FIG. 4, the parity nodes are degree-2 variable nodes that are deterministically placed and connected to the check nodes in a zigzag shape.

With this feature, it can be shown that any parity nodes punctured can be recovered during a certain number of iterations if there is at least one unpunctured parity node and all the information nodes are not punctured. This can be readily verified. Consider FIG. 4, in which the check nodes at which the unpunctured node is connected are survived check nodes because all the information nodes are not punctured and they only have at most one punctured node connected, i.e., the node right at the left or right of unpunctured node. As long as the node at the left or right is punctured, it can be recovered in the first iteration. After these two punctured nodes are recovered, the one at the next left or right can be recovered in the next decoding iteration. Based on the above, it is thus reasonable to consider only puncturing the parity nodes, so that one can obtain highest recoverable rate K/(K+1), where K is the block length of information sequence.

Next, consider the recoverable steps of the punctured parity nodes. FIG. 7 depicts a pattern of punctured parity nodes in an IRA code. Consider J consecutive punctured parity nodes shown in left part of FIG. 7. It is seen that the most left and right one are 1SR node, or denoted by 1SR, then second ones are 2SR. Then one knows the largest steps in J consecutive punctured nodes is ┌J/2┐. We find that it is the only pattern of punctured parity nodes in an IRA code so that the punctured nodes can be easily assigned to the group G_(k) by k=min{i, J+1−i}, where i is the index, start with 1 from one side of J consecutive punctured nodes. Hence, to puncture N_(p) nodes to an IRA with M parity nodes the optimal solution to minimizing K_(G) is evenly puncturing J consecutive nodes at the parity nodes if J>1, where J=┌N_(p)/(M−N_(p))┐. If there is a remainder in the division, there exist some J−1 consecutive puncture nodes. For J=1, one can simply place the N_(p) punctured node evenly without consecutiveness. The inventors refer to this as deliberate puncturing. For instance, given a (N=2048, K=1024) IRA code as the mother code, the patterns of deliberate puncturing of different rate are shown in FIG. 8, where N_(p)/M is the puncture rate over the parity nodes.

With deliberate puncturing, one can puncture any N_(p) nodes to obtain optimal punctured IRA codes. However, they are are not rate-compatible. In order to get rate-compatibility, the puncturing approach illustrated by FIG. 5 proceeds in a reverse way, i.e., deliberately puncture the mother codes to the code with the highest rate R_(M), then unpuncture those punctured nodes to obtain lower rate. The reason is that empirically one knows that the puncturing pattern is always more important to the higher rate RC codes. For instance, we have deliberately punctured codes in a pattern of J consecutive nodes, then K_(G)=┌J/2┐. If we further puncture a parity node, it will form a streak of 2J+1 consecutive punctured nodes. Then K_(G)=J+1. This large increased K_(G) will significantly degrade the performance of the high rate code.

It can be shown that the above puncturing approach provides rate compatible IRA-type LDPC codes which provide good performance from medium to very high code rates. It should be noted that with the above puncturing approach, one can obtain the codes with continuous rates by unpuncturing the node one by one. One can pick any rates to form a set of RC-LDPC codes. One can also modify the unpuncture strategy above slightly for fixed discrete R_(i)s. The performance of resulting RC-LDPC codes, however, would not be much different.

It is useful to compare the above approach with the prior art puncturing approach disclosed in See J. Ha and S. McLaughlin, “Puncturing for Finite Length low density parity check Codes,” in Proc. IEEE Int. Symp. Inform. Theory (ISIT), p. 151 (June 2004). While this prior art puncturing approach is also based on grouping nodes with different recoverable steps, it is focused on handling regular LDPC codes rather than irregular IRA-type LDPC codes. A greedy search algorithm is therein proposed to find the optimal set of groups {G_(k)}_(k=1) ^(K) ^(G) from all variable nodes by minimizing K_(G). After the set of G_(k) are obtained, the puncturing is then performed by puncturing the nodes in G₁ first, after using up all nodes in G₁, then G₂, and G₃, . . . , until all RC-LDPC codes with rate R₁, R₂, . . . , R_(M) are gradually obtained. With this puncturing algorithm, all the punctured nodes are recoverable (or having a reliable message instead of 0) after the K_(G)th decoding iterations.

EXTENDING. The rate compatible code disclosed above can be extended to lower rates by adding extra redundancy bits, as further described below. An advantage of extending is the reduction of complexity. Unlike puncturing, additional parity bits can be appended only when needed, and decoding is only performed for the bits transmitted. Therefore, unnecessary computations are avoided at the encoder and decoder. Since it is difficult to obtain a good high rate LDPC code due to the small size of the code graph, the mother code for extending is preferably of moderate rate.

FIG. 9 illustrates how new codes can be obtained by introducing additional bits and adding additional constraints (rows) for both the new and old nodes in the parity check matrix. For instance, new rows of [C₁, B₁] and [C₂, B₂] are included to obtain the rate K₀/N₁ and K₀/N₂. Because N₂−M₂=N₁−M₁=K₀, B₁ and B₂ are square and have full rank; C₁ and C₂ are sparse. The entries above B₁ and B₂ have to be zero to achieve rate-compatibility. The optimal profiles of B₁, C₁ and B₂, C₂ can be obtained through density evolution. For IRA codes, B₁ and B₂ represent the extended degree-2 parity nodes; thus, the extended matrices are fixed with two 1's in each column and placed in a stairway shape, as shown in FIG. 9. Therefore, only the columns in C_(1,2) representing information bits contain nonzero entries; and we need to consider the design of these non-zero entries in C_(1,2) to obtain good extended codes. There are two issues we may consider. First, the profiles of the extended code ensemble can be optimized. Second, the design of particular C_(1,2) can be treated as finite-length code design to satisfy unequal protection of the coded bits with different types of cycles.

Define ${{\phi(x)} = {1 - {E\left\lbrack {\tanh\left( \frac{u}{2} \right)} \right\rbrack}}},$ where u˜N (χ, 2χ), and φ(0)=1. Based on density evolution analysis with Gaussian approximation, the iterative process of IRA decoding from the lth iteration to the (l+1)th iteration can be represented by $\begin{matrix} {r^{\ell + 1} = {h\left( {s,r^{\ell},{\overset{\sim}{r}}^{\ell}} \right)}} & (6) \\ {{{{with}{\quad\quad}{h\left( {s,r,\overset{\sim}{r}} \right)}} = {\sum\limits_{i = 2}^{D}{\lambda_{i}{h_{i}\left( {s,r,\overset{\sim}{r}} \right)}}}},} & (7) \\ {{{h_{i}\left( {s,r,r} \right)}\overset{\Delta}{=}{\phi\left( {s + {\left( {i - 1} \right){\phi^{- 1}\left( {1 - {\left( {1 - r} \right)^{a - 1}\left( {1 - \overset{\sim}{r}} \right)^{2}}} \right)}}} \right)}},} & (8) \\ {{{{and}\quad{\overset{\sim}{h}\left( {s,r,\overset{\sim}{r}} \right)}}\overset{\Delta}{=}{\phi\left( {s + {\phi^{- 1}\left( {1 - {\left( {1 - r} \right)^{a}\left( {1 - \overset{\sim}{r}} \right)}} \right)}} \right)}},} & (9) \end{matrix}$ where i is the degree of information nodes; h (s, r, {tilde over (r)}) is the function of updating extrinsic messages from the check node to the information nodes, and {tilde over (h)} (s, r, {tilde over (r)}) is the function of updating extrinsic message to the parity nodes; s=4E_(s)/N₀; r and {tilde over (r)} are scalars of extrinsic messages passed between the information nodes and parity nodes, respectively. Then, the IRA code optimization for AWGN channel is to find the optimal code ensemble profile {λ_(i), α} which maximizes the code rate R and subject to the error-free decoding constraint, r^(l+1)<r^(l), i.e., $\begin{matrix} {{\underset{{\{\lambda_{i}\}},a}{maximize}a{\sum\limits_{i = 2}^{D}{\lambda_{i}/i}}},{{{s.t.r} > {{h\left( {s,r,{\overset{\sim}{r}(r)}} \right)}\quad{and}\quad{\sum\limits_{i = 2}^{D}\lambda_{i}}}} = 1},} & (10) \end{matrix}$ where {tilde over (r)}(r) denotes the solution of {tilde over (r)}=h(s,r,{tilde over (r)}),   (11) for a given r. Note that the function φ(χ) is monotonically decreasing. Then, given a fixed s, for all r∈[0, 1], the function {tilde over (h)}(s,r, {tilde over (r)}) is monotonically increasing with {tilde over (r)}. Since {tilde over (h)}(s, r, 0)≧0 and {tilde over (h)}(s, r, 1)≦1, (11) has a unique solution in (0,1).

If the group factor α is different for each step of extending, the check nodes may no longer be regular. Therefore, we define the distribution ρ_(α)as the degree fraction of group factor α. We then rewrite equations (8) and (9) as $\begin{matrix} {{{h_{i}\left( {s,r,\overset{\sim}{r}} \right)}\overset{\Delta}{=}{\phi\left( {s + {\left( {i - 1} \right){\phi^{- 1}\left( {1 - {\left( {1 - \overset{\sim}{r}} \right)^{2}{\sum\limits_{a}{\rho_{a}\left( {1 - r} \right)}^{a - 1}}}} \right)}}} \right)}},} & (12) \\ {{{{and}\quad{\overset{\sim}{h}\left( {s,r,\overset{\sim}{r}} \right)}}\overset{\Delta}{=}{\phi\left( {s + {\phi^{- 1}\left( {1 - {\left( {1 - \overset{\sim}{r}} \right){\sum\limits_{a}{{\overset{\sim}{\rho}}_{a}\left( {1 - \overset{\sim}{r}} \right)}^{a}}}} \right)}} \right)}},} & (13) \end{matrix}$ where {tilde over (ρ)}_(α)is the degree distribution from the node perspective. In order to obtain the profiles with rate compatibility, additional constraints are introduced. Given the profiles of the RC code of rate R_(q) at the qth stage, {λ_(q,i), ρ_(q,α)}, the constraints for next extended code ensemble, {λ_(q+1,i, ρ) _(q+1,α)} of rate R_(q+1), where R_(q+1)<R_(q), can be obtained as follows.

Define the scaling factor α_(q)=M_(q)/M_(q+1). We assume that the group factor remains the same in the matrix C_(q) at the qth extension, denoted by α_(q), for all q=1, 2, . . . . The RC constraint for ρ_(q+1,α) from a node perspective is given by $\begin{matrix} {{{\overset{\sim}{\rho}}_{{q + 1},a} = {\beta_{q}{\overset{\sim}{\rho}}_{q,a}}},{{{for}\quad a} \neq a_{q + 1}},{{\overset{\sim}{\rho}}_{{q + 1},a} = {1 - {\left( {1 - {\overset{\sim}{\rho}}_{q,a}} \right)\beta_{q}}}},{{{for}\quad a} = a_{q + 1}},{q = {1,2,\quad\ldots}}\quad,{{{where}\quad{\overset{\sim}{\rho}}_{q,a}} = \frac{\rho_{q,a}/a}{\sum\limits_{j}^{\quad}{\rho_{q,j}/j}}},{\rho_{q,a} = {\frac{{\overset{\sim}{\rho}}_{q,a}a}{\sum\limits_{j}^{\quad}{{\overset{\sim}{\rho}}_{q,j}j}}.}}} & (14) \end{matrix}$ Since additional SPC constraints imposed for extending can possibly increase the degrees of information nodes, the constraints for the degree profiles from the node perspective are given by $\begin{matrix} {{{{\sum\limits_{i = k}^{D_{q + 1}}{\overset{\sim}{\lambda}}_{{q + 1},i}} \geq {\sum\limits_{i = k}^{D_{q}}{\overset{\sim}{\lambda}}_{q,i}}},{{{for}\quad k} = 2},3,\ldots\quad,{where}}{{{\overset{\sim}{\lambda}}_{q,i} = \frac{\lambda_{q,i}/i}{\sum\limits_{j}^{D_{q}}{\lambda_{q,j}/j}}},{\lambda_{q,i} = \frac{{\overset{\sim}{\lambda}}_{q,i}i}{\sum\limits_{j}^{D_{q}}{{\overset{\sim}{\lambda}}_{q,j}j}}},}} & (15) \end{matrix}$ With the above constraints, we can then obtain the optimal extending profiles using differential evolution for LDPC code design.

It has been determined that degree-1 nodes play an important role in designing low-rate codes. In particular, a massive number of degree-1 nodes are extended for an LDPC code in order to design a very low-rate code with capacity-approaching coding gain. Hence, instead of extending solely with degree-2 nodes, we propose a new extending method which includes the degree-1 parity bits to obtain RC-IRA codes at lower rates. The columns of the extended matrix B₁ and B₂ then have either two or one nonzero entry placed at the diagonal positions, as shown in the right part of FIG. 9. A bipartite graph representation of the extended code is depicted in FIG. 10. It is then natural to ask what is the optimal proportion of degree-1 and degree-2 parity nodes for extending. The solution can also be found by the density evolution analysis of iterative IRA decoding.

Define π_(q,α) as the proportion of degree-1 nodes connected to the check nodes (including extended nodes) with grouping factor α at the qth extending stage. Hence, function h_(i) and {tilde over (h)} in (8) and (9) can be written as $\begin{matrix} {\begin{matrix} {{h_{q,i}\left( {s,r,\overset{\sim}{r}} \right)} = {\phi\left( {s + {\left( {i - 1} \right){\phi^{- 1}\left( {1 - {\sum\limits_{a}{\rho_{q,a}\left( \left( {1 - \pi_{q,a}} \right) \right.}}} \right.}}} \right.}} \\ {\left. \left. \left. {{\left( {1 - r} \right)^{a - 1}\left( {1 - \overset{\sim}{r}} \right)^{2}} + {{\pi_{q,a}\left( {1 - r} \right)}^{a - 1}\left( {1 - r_{0}} \right)}} \right) \right) \right),} \end{matrix}{and}} & (16) \\ {{{{\overset{\sim}{h}}_{q}\left( {s,r,\overset{\sim}{r}} \right)} = {\phi\left( {s + {\phi^{- 1}\left( {1 - {\sum\limits_{a}{{{\overset{\sim}{\rho}}_{q,a}\left( {1 - \pi_{q,a}} \right)}\left( {1 - r} \right)^{a}\left( {1 - \overset{\sim}{r}} \right)}}} \right)}} \right)}},} & (17) \end{matrix}$ where r₀=φ(s). Here we assume that the check nodes connected to the extended degree-2 and degree-1 parity nodes have the same grouping factor at each extending stage. Define π_(q)* as the proportion of degree-1 parity nodes over the extended nodes (with total equal to M_(q)−M_(q−1)) at the qth stage. We have π_(q+1,α)=π_(q,α) for α≠α_(q+1),   (18) π_(q+1,α)=β_(q){tilde over (ρ)}_(q,α)π_(q,α)+(1−β_(q))π_(q+1)* for α=α_(q+1).   (19) It is seen that only π_(q+1)* is introduced to the design of the code profile at the (q+1)th extending stage (π_(q+1,a) can be obtained from (18) and (19)). The optimization at the qth extending stage can be summarized as $\begin{matrix} {{{\min\limits_{{\{\lambda_{q,i}\}},a_{q},\pi_{q}^{*}}{{E_{b}/N_{0}}\quad{s.t.\quad r}}} > {h\left( {s,r,\overset{\sim}{r}} \right)}},{{and}{\quad\quad}{the}{\quad\quad}{constraints}\quad{in}\quad{(15).}}} & (20) \end{matrix}$ Again, the above optimization can be solved by differential evolution.

The code profile obtained from the above optimization to achieve the threshold of E_(b)/N₀ is for infinite-length random codes with cycle-free assumption. For practical applications, it might be difficult to build a good finite-length code (i.e., a few thousand bits or less) from the optimized profiles since the cycles are impossible to avoid. Under the iterative decoding, the existence of cycles causes the error-floor. The above-mentioned patent application proposes a finite-length code design method by introducing unequal protection of variable nodes with distinguishing different type of cycles in the bipartite graph representation of IRA codes. Here, we can apply the same design strategy to build an extended code matrix of R<R₀. Thus, in order to find the good tradeoff between low threshold decoding and low error-floors, consider the following simplifications.

-   -   Since the nodes of large degrees make the cycle control         difficult to achieve when constructing a practical code matrix,         it can be assumed that the edges from extended check nodes are         evenly connected to the information nodes. Then there are only         two consecutive components in the profile of information nodes,         i.e., λ_(q,i) and λ_(q,i−1). Hence, we only need optimize α_(q),         π_(α) _(q) since λ_(q,i) and λ_(q,i−1), are determined by α_(q),         given by $\begin{matrix}         {{\lambda_{q,{i + {\lceil\alpha\rceil}}} = {\alpha - \left\lfloor \alpha \right\rfloor}},{\lambda_{q,{i + {\lfloor\alpha\rfloor}}} = {\left\lceil \alpha \right\rceil - \alpha}},{where}} & (21) \\         {\alpha = {\frac{\left( {{a_{q}\left( {M_{q} - M_{q - 1}} \right)} - {K\quad\lambda_{{q - 1},{i - 1}}}} \right)}{K}\quad = {{a_{q}\left( {\frac{1}{R_{q}} - \frac{1}{R_{q - 1}}} \right)} - {\lambda_{{q - 1},{i - 1}}.}}}} & (22)         \end{matrix}$

-   It is advantageous to limit the maximum possible value of α due to     the same reason that large α will lead to large degrees on the     information nodes which brings up difficulties on the cycle control.     With this simplification, we can simply search the optimized π_(q)*     for any given α_(q)<α_(max) and find the best pair of π_(q)*, α_(q).

Define function ƒ(s,r,{tilde over (r)},π _(q)*)

h(s,r,{tilde over (r)})−r,   (23) where h (s, r, {tilde over (r)}) can be computed by (7), (16) and (17) applying the above simplification results. With error-free decoding constraint, r>h (s, r, {tilde over (r)}), we have ƒ(s, r, {tilde over (r)}, π)<0. Then given α_(q), the profiles of the RC codes at the (q−1)th stage, and the target rate R_(q), the optimal π_(q)* can be obtained by solving $\begin{matrix} {{\min\limits_{\pi_{q}^{*}}{{E_{b}/N_{0}}\quad{s.t.\quad{f\left( {s,r,\overset{\sim}{r},\pi_{q}^{*}} \right)}}}} < 0.} & (24) \end{matrix}$

Consider an example of extending to a very low rate, R_(q)=0.1, q=1, directly from the mother code. The mother code is obtained from finite-length LDPC design strategy with R₀=0.5 and profiles {λ₅=1, α=5}. The function ƒ(s, r, {tilde over (r)}, π_(q)*) for π_(q)*=0.6, 0.75, . . . , 1 and α_(q)=3 is evaluated and illustrated in FIG. 11. We find that at this SNR, E_(b)/N₀=−0.83 dB, almost all the curves of ƒ(s, r, {tilde over (r)}, π_(q)*) cross over the line y=0, i.e., ƒ(s, r, {tilde over (r)}, π_(q)*)>0, indicating the decoding will fail since error-free decoding constraint is not satisfied. The exception is the optimal result, π_(q)*=0.82, which is tangent to y=0 line. If we further decrease the value of SNR, we cannot obtain any solution of π_(q)* that satisfy ƒ(s, r, {tilde over (r)}, π_(q)*)<0. Hence, minimum SNR is achieved and π_(q)*=0.82 is the optimal result for this case.

While exemplary drawings and specific embodiments of the present invention have been described and illustrated, it is to be understood that that the scope of the present invention is not limited to the particular embodiments discussed. Thus, the embodiments shall be regarded as illustrative rather than restrictive, and it should be understood that variations may be made in those embodiments by workers skilled in the arts without departing from the scope of the present invention as set forth in the claims that follow and their structural and functional equivalents. 

1. A method for generating rate-compatible codes for a digital data communication system comprising the steps of: puncturing a maximum number of parity nodes in an initial low density parity check code to obtain a first low density parity check code with a high code rate; and unpuncturing at least one of the punctured parity nodes in the first low density parity check code so as to obtain a next low density parity check code with a code rate lower than the high code rate.
 2. The method of claim 1 wherein the maximum number of parity nodes is deliberately punctured to minimize maximum step recoverable punctured nodes.
 3. The method of claim 1 wherein the punctured parity nodes are unpunctured based a grouping of the parity nodes based on recoverable steps.
 3. The method of claim 2 wherein the punctured parity nodes with a maximum recoverable step are unpuctured first.
 4. The method of claim 3 wherein consecutive punctured parity nodes with a maximum recoverable step are unpunctured before other punctured parity nodes with a maximum recoverable step.
 5. The method of claim 1 wherein the low density parity check code is an irregular repeat accumulate (IRA) code.
 6. A digital data communication system which utilizes hybrid automatic repeat request (ARQ) with rate-compatible codes generated by the method of claim
 1. 7. A transmitter with an encoder which encodes transmissions using rate-compatible codes generated by the method of claim
 1. 8. A receiver with a decoder which decodes transmissions using rate-compatible codes generated by the method of claim
 1. 9. A method for generating rate-compatible codes for a digital data communication system comprising the steps of: extending an initial low density parity check code with at least one degree-1 parity node so as to obtain a first low density parity check code with a lower code rate.
 10. The method of claim 9 wherein the initial low density parity check code is also extended with at least one degree-2 parity node, and wherein the number of degree-1 parity nodes and the number of degree-2 parity nodes is extended in accordance with an optimized proportion.
 11. The method of claim 10 wherein the optimized proportion is determined from density evolution analysis of the initial low density parity check code.
 12. The method of claim 9 wherein the low density parity check code is an irregular repeat accumulate (IRA) code.
 13. A digital data communication system which utilizes hybrid automatic repeat request (ARQ) with rate-compatible codes generated by the method of claim
 9. 14. A transmitter with an encoder which encodes transmissions using rate-compatible codes generated by the method of claim
 9. 15. A receiver with a decoder which decodes transmissions using rate-compatible codes generated by the method of claim
 9. 16. A method for generating rate-compatible codes for a digital data communication system comprising the steps of: generating higher-rate codes from an initial low density parity check code by puncturing a maximum number of parity nodes in the initial low density parity check code to obtain a first low density parity check code with a high code rate, and unpuncturing at least one of the punctured parity nodes in the first low density parity check code so as to obtain a next low density parity check code with a code rate lower than the high code rate and higher than an initial code rate; and generating lower-rate codes from the initial low density parity check code by extending the initial low density parity check code with at least one degree-1 parity node so as to obtain another low density parity check code with a lower code rate than the initial code rate.
 17. The method of claim 16 wherein the low density parity check code is an irregular repeat accumulate (IRA) code.
 18. A digital data communication system which utilizes hybrid automatic repeat request (ARQ) with rate-compatible codes generated by the method of claim
 16. 19. A transmitter with an encoder which encodes transmissions using rate-compatible codes generated by the method of claim
 16. 20. A receiver with a decoder which decodes transmissions using rate-compatible codes generated by the method of claim
 16. 